package com.hdu;


import java.util.concurrent.TimeUnit;

import static com.hdu.TimeUtils.printCurTime;

public class Main {
    public static void main(String[] args) {
        testTimeOutSync();
    }


    /**
     * 测试异步不超时
     */
    public static void testNormalAsync() {
        System.out.print("开始执行, 时间 : ");
        printCurTime();
        RequestExecutor.doRequestAsync(
                () -> {
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    return "正常返回结果";
                },
                (res, e) -> {
                    System.out.print("触发回调逻辑, 时间 : ");
                    printCurTime();
                    System.out.println(res);
                },
                2,
                TimeUnit.SECONDS,
                "默认返回结果"
        );
        //开始执行, 时间 : 2024-08-13 00:26:54
        //触发回调逻辑, 时间 : 2024-08-13 00:26:55
        //正常返回结果
    }

    /**
     * 测试异步超时
     */
    public static void testTimeOutAsync() {
        System.out.print("开始执行, 时间 : ");
        printCurTime();
        RequestExecutor.doRequestAsync(
                () -> {
                    // 模拟耗时操作 2s
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    return "正常返回结果";
                },
                (res, e) -> {
                    System.out.print("触发回调逻辑, 时间 : ");
                    printCurTime();
                    System.out.println(res);
                },
                1,
                TimeUnit.SECONDS,
                "默认返回结果"
        );
        // 开始执行, 时间 : 2024-08-13 00:27:30
        // 触发回调逻辑, 时间 : 2024-08-13 00:27:31
        // 默认返回结果
    }


    /**
     * 测试同步超时
     */
    public static void testTimeOutSync() {
        System.out.print("开始执行, 时间 : ");
        printCurTime();
        String res = RequestExecutor.doRequestSync(
                () -> {
                    // 模拟耗时操作 2s
                    try {
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    return "正常返回结果";
                },
                1,
                TimeUnit.SECONDS,
                "默认返回结果"
        );
        System.out.print("结果 ：" + res + ", 时间 ：");
        printCurTime();
        // 开始执行, 时间 : 2024-08-13 00:32:27
        // 结果 ：默认返回结果, 时间 ：2024-08-13 00:32:28
    }

    /**
     * 测试同步正常
     */
    public static void testNormalSync() {
        System.out.print("开始执行, 时间 : ");
        printCurTime();
        String res = RequestExecutor.doRequestSync(
                () -> {
                    return "正常返回结果";
                },
                2,
                TimeUnit.SECONDS,
                "默认返回结果"
        );
        System.out.print("结果 ：" + res + ", 时间 ：");
        printCurTime();
        // 开始执行, 时间 : 2024-08-13 00:32:02
        // 结果 ：正常返回结果, 时间 ：2024-08-13 00:32:02
    }
}
